const std = @import("std");

/// 关键字类型 - 支持中英文
pub const KeywordType = enum {
    // 变量声明
    Const, // const / 常
    Var, // var / 设
    Let, // let / 令

    // 函数和可见性
    Fn, // fn / 函数
    Pub, // pub / 公开
    Priv, // priv / 私有
    Export, // export / 导出

    // 控制流
    If, // if / 如果
    Else, // else / 否则
    ElseIf, // else if / 否则如果
    While, // while / 当
    For, // for / 遍历
    Loop, // loop / 循环
    Return, // return / 返回
    Break, // break / 跳出
    Continue, // continue / 继续
    Match, // match / 匹配
    Case, // case / 情况
    Default, // default / 默认

    // 类型和结构
    Struct, // struct / 结构
    Enum, // enum / 枚举
    Union, // union / 联合
    Type, // type / 类型
    Trait, // trait / 特征
    Impl, // impl / 实现
    Interface, // interface / 接口
    Class, // class / 类

    // 模块和导入
    Import, // import / 导入
    Module, // module / 模块
    Use, // use / 使用
    From, // from / 从
    As, // as / 作为
    Package, // package / 包

    // 错误处理
    Try, // try / 尝试
    Catch, // catch / 捕获
    Error, // error / 错误
    Throw, // throw / 抛出
    Finally, // finally / 最终

    // 并发
    Actor, // actor / 角色
    Async, // async / 异步
    Await, // await / 等待
    Receive, // receive / 接收
    Send, // send / 发送
    Spawn, // spawn / 生成
    Thread, // thread / 线程
    Mutex, // mutex / 互斥锁

    // 内存管理
    Defer, // defer / 延迟
    Errdefer, // errdefer / 错误延迟
    Comptime, // comptime / 编译期
    Inline, // inline / 内联
    Noinline, // noinline / 不内联

    // 测试和调试
    Test, // test / 测试
    Assert, // assert / 断言
    Debug, // debug / 调试
    Unreachable, // unreachable / 不可达

    // 布尔值和特殊值
    True, // true / 真
    False, // false / 假
    Null, // null / 空
    Undefined, // undefined / 未定义

    // 其他
    In, // in / 在
    Is, // is / 是
    Not, // not / 非
    And, // and / 与
    Or, // or / 或
    New, // new / 新建
    Delete, // delete / 删除
    Sizeof, // sizeof / 大小
    Typeof, // typeof / 类型
    This, // this / 这个
    Self, // self / 自己
    Super, // super / 父类
};

/// 关键字映射表 - 中英文都映射到相同的 KeywordType
pub const keyword_map = std.ComptimeStringMap(KeywordType, .{
    // 英文关键字 - 变量声明
    .{ "const", .Const },
    .{ "var", .Var },
    .{ "let", .Let },

    // 英文关键字 - 函数和可见性
    .{ "fn", .Fn },
    .{ "pub", .Pub },
    .{ "priv", .Priv },
    .{ "export", .Export },

    // 英文关键字 - 控制流
    .{ "if", .If },
    .{ "else", .Else },
    .{ "while", .While },
    .{ "for", .For },
    .{ "loop", .Loop },
    .{ "return", .Return },
    .{ "break", .Break },
    .{ "continue", .Continue },
    .{ "match", .Match },
    .{ "case", .Case },
    .{ "default", .Default },

    // 英文关键字 - 类型和结构
    .{ "struct", .Struct },
    .{ "enum", .Enum },
    .{ "union", .Union },
    .{ "type", .Type },
    .{ "trait", .Trait },
    .{ "impl", .Impl },
    .{ "interface", .Interface },
    .{ "class", .Class },

    // 英文关键字 - 模块和导入
    .{ "import", .Import },
    .{ "module", .Module },
    .{ "use", .Use },
    .{ "from", .From },
    .{ "as", .As },
    .{ "package", .Package },

    // 英文关键字 - 错误处理
    .{ "try", .Try },
    .{ "catch", .Catch },
    .{ "error", .Error },
    .{ "throw", .Throw },
    .{ "finally", .Finally },

    // 英文关键字 - 并发
    .{ "actor", .Actor },
    .{ "async", .Async },
    .{ "await", .Await },
    .{ "receive", .Receive },
    .{ "send", .Send },
    .{ "spawn", .Spawn },
    .{ "thread", .Thread },
    .{ "mutex", .Mutex },

    // 英文关键字 - 内存管理
    .{ "defer", .Defer },
    .{ "errdefer", .Errdefer },
    .{ "comptime", .Comptime },
    .{ "inline", .Inline },
    .{ "noinline", .Noinline },

    // 英文关键字 - 测试和调试
    .{ "test", .Test },
    .{ "assert", .Assert },
    .{ "debug", .Debug },
    .{ "unreachable", .Unreachable },

    // 英文关键字 - 布尔值和特殊值
    .{ "true", .True },
    .{ "false", .False },
    .{ "null", .Null },
    .{ "undefined", .Undefined },

    // 英文关键字 - 其他
    .{ "in", .In },
    .{ "is", .Is },
    .{ "not", .Not },
    .{ "and", .And },
    .{ "or", .Or },
    .{ "new", .New },
    .{ "delete", .Delete },
    .{ "sizeof", .Sizeof },
    .{ "typeof", .Typeof },
    .{ "this", .This },
    .{ "self", .Self },
    .{ "super", .Super },

    // 中文关键字 - 变量声明
    .{ "常", .Const },
    .{ "常量", .Const },
    .{ "设", .Var },
    .{ "变量", .Var },
    .{ "令", .Let },
    .{ "让", .Let },

    // 中文关键字 - 函数和可见性
    .{ "函数", .Fn },
    .{ "方法", .Fn },
    .{ "公开", .Pub },
    .{ "公有", .Pub },
    .{ "私有", .Priv },
    .{ "导出", .Export },

    // 中文关键字 - 控制流
    .{ "如果", .If },
    .{ "若", .If },
    .{ "否则", .Else },
    .{ "不然", .Else },
    .{ "当", .While },
    .{ "只要", .While },
    .{ "遍历", .For },
    .{ "对于", .For },
    .{ "循环", .Loop },
    .{ "返回", .Return },
    .{ "跳出", .Break },
    .{ "中断", .Break },
    .{ "继续", .Continue },
    .{ "匹配", .Match },
    .{ "情况", .Case },
    .{ "默认", .Default },

    // 中文关键字 - 类型和结构
    .{ "结构", .Struct },
    .{ "结构体", .Struct },
    .{ "枚举", .Enum },
    .{ "联合", .Union },
    .{ "联合体", .Union },
    .{ "类型", .Type },
    .{ "特征", .Trait },
    .{ "实现", .Impl },
    .{ "接口", .Interface },
    .{ "类", .Class },

    // 中文关键字 - 模块和导入
    .{ "导入", .Import },
    .{ "引入", .Import },
    .{ "模块", .Module },
    .{ "使用", .Use },
    .{ "从", .From },
    .{ "作为", .As },
    .{ "包", .Package },

    // 中文关键字 - 错误处理
    .{ "尝试", .Try },
    .{ "试图", .Try },
    .{ "捕获", .Catch },
    .{ "捕捉", .Catch },
    .{ "错误", .Error },
    .{ "抛出", .Throw },
    .{ "最终", .Finally },

    // 中文关键字 - 并发
    .{ "角色", .Actor },
    .{ "异步", .Async },
    .{ "等待", .Await },
    .{ "接收", .Receive },
    .{ "发送", .Send },
    .{ "生成", .Spawn },
    .{ "线程", .Thread },
    .{ "互斥锁", .Mutex },
    .{ "锁", .Mutex },

    // 中文关键字 - 内存管理
    .{ "延迟", .Defer },
    .{ "错误延迟", .Errdefer },
    .{ "编译期", .Comptime },
    .{ "内联", .Inline },
    .{ "不内联", .Noinline },

    // 中文关键字 - 测试和调试
    .{ "测试", .Test },
    .{ "断言", .Assert },
    .{ "调试", .Debug },
    .{ "不可达", .Unreachable },

    // 中文关键字 - 布尔值和特殊值
    .{ "真", .True },
    .{ "假", .False },
    .{ "空", .Null },
    .{ "未定义", .Undefined },

    // 中文关键字 - 其他
    .{ "在", .In },
    .{ "是", .Is },
    .{ "非", .Not },
    .{ "不", .Not },
    .{ "与", .And },
    .{ "且", .And },
    .{ "或", .Or },
    .{ "新建", .New },
    .{ "删除", .Delete },
    .{ "大小", .Sizeof },
    .{ "类型", .Typeof },
    .{ "这个", .This },
    .{ "自己", .Self },
    .{ "父类", .Super },
});

/// 检查是否为关键字
pub fn getKeyword(lexeme: []const u8) ?KeywordType {
    return keyword_map.get(lexeme);
}

/// 获取关键字的英文表示（用于代码生成）
pub fn toEnglish(keyword: KeywordType) []const u8 {
    return switch (keyword) {
        .Const => "const",
        .Var => "var",
        .Let => "const", // let 在 Zig 中也是 const
        .Fn => "fn",
        .Pub => "pub",
        .If => "if",
        .Else => "else",
        .While => "while",
        .For => "for",
        .Return => "return",
        .Break => "break",
        .Continue => "continue",
        .Struct => "struct",
        .Enum => "enum",
        .Union => "union",
        .Type => "type",
        .Trait => "trait",
        .Impl => "impl",
        .Import => "import",
        .Module => "module",
        .Use => "use",
        .Try => "try",
        .Catch => "catch",
        .Error => "error",
        .Actor => "actor",
        .Async => "async",
        .Await => "await",
        .Receive => "receive",
        .Test => "test",
        .True => "true",
        .False => "false",
    };
}

/// 获取关键字的中文表示
pub fn toChinese(keyword: KeywordType) []const u8 {
    return switch (keyword) {
        .Const => "常",
        .Var => "设",
        .Let => "令",
        .Fn => "函数",
        .Pub => "公开",
        .If => "如果",
        .Else => "否则",
        .While => "当",
        .For => "遍历",
        .Return => "返回",
        .Break => "跳出",
        .Continue => "继续",
        .Struct => "结构",
        .Enum => "枚举",
        .Union => "联合",
        .Type => "类型",
        .Trait => "特征",
        .Impl => "实现",
        .Import => "导入",
        .Module => "模块",
        .Use => "使用",
        .Try => "尝试",
        .Catch => "捕获",
        .Error => "错误",
        .Actor => "角色",
        .Async => "异步",
        .Await => "等待",
        .Receive => "接收",
        .Test => "测试",
        .True => "真",
        .False => "假",
    };
}

test "keyword lookup - English" {
    try std.testing.expectEqual(KeywordType.Const, getKeyword("const").?);
    try std.testing.expectEqual(KeywordType.Var, getKeyword("var").?);
    try std.testing.expectEqual(KeywordType.Let, getKeyword("let").?);
    try std.testing.expectEqual(KeywordType.Fn, getKeyword("fn").?);
}

test "keyword lookup - Chinese" {
    try std.testing.expectEqual(KeywordType.Const, getKeyword("常").?);
    try std.testing.expectEqual(KeywordType.Var, getKeyword("设").?);
    try std.testing.expectEqual(KeywordType.Let, getKeyword("令").?);
    try std.testing.expectEqual(KeywordType.Fn, getKeyword("函数").?);
}

test "keyword conversion" {
    try std.testing.expectEqualStrings("const", toEnglish(.Const));
    try std.testing.expectEqualStrings("常", toChinese(.Const));
    try std.testing.expectEqualStrings("var", toEnglish(.Var));
    try std.testing.expectEqualStrings("设", toChinese(.Var));
}
